package com.saprk.demoarithmetic.leetcode;


import org.apache.commons.lang3.StringUtils;

/**
 * @author fuqiang
 * @Description 中极
 * @Date 2021-05-26
 */
public class Middle {
    /**
     * 找出最长回文子串  版本二 以中心为准 左右扩散法
     * @author fuqiang
     * @date 2021/6/2 17:41
     * @param s
     * @return java.lang.String
     */
    public static String longestPalindrome2(String s) {
        int length = s.length();
        // 校验
        if(StringUtils.isEmpty(s) || length <= 1){
            return s;
        }
        // 最长回文子串
        int left , right ;
        int len = 0;
        int maxLen = 1;
        int maxStart = 0;
        for (int i = 0; i < length; i++) {
            left = i - 1;
            right = i + 1;
            // 往左扩散
            while (left >= 0 && s.charAt(left) == s.charAt(i)){
                len++ ;
                left--;
            }
            // 往右扩散
            while (right < length && s.charAt(right) == s.charAt(i)){
                len++ ;
                right++;
            }
            // 左右扩散判断是否相等
            while (left >= 0 && right < length && s.charAt(right) == s.charAt(left)){
                len += 2 ;
                right++;
                left--;
            }
            // 长度更新
            if(len > maxLen){
                maxLen = len;
                maxStart = left;
            }
            // 归位
            len = 1;
        }

        return s.substring(maxStart + 1, maxStart + maxLen + 1);
    }
    /**
     * 找出最长回文子串 轮询时间太长了
     * @author fuqiang
     * @date 2021/6/2 16:56
     * @param s
     * @return java.lang.String
     */
    public static String longestPalindrome(String s) {
        int length = s.length();
        // 校验
        if(StringUtils.isEmpty(s) || length <= 1){
            return s;
        }
        // 最长回文子串
        String longestPalindrome = "" ;
        for (int i = 0; i < length; i++) {
            for (int j = i+2; j <= length; j++) {
                String substring = s.substring(i, j);
                // 判断是否是回文数
                if(isCheckPalinrome(substring)){
                    if(substring.length() >= longestPalindrome.length()){
                        longestPalindrome = substring;
                    }
                }
            }
        }
        if(StringUtils.isEmpty(longestPalindrome)){
            return s.substring(0,1);
        }
        return longestPalindrome;
    }
    /**
     * 检查是否是回文数
     * @author fuqiang
     * @date 2021/6/2 17:25
     * @param substring
     * @return boolean
     */
    private static boolean isCheckPalinrome(String substring) {
        return new StringBuffer(substring).reverse()
                .toString().equalsIgnoreCase(substring);
    }

    /**
     * 无重复字符的最长子串
     * @param s
     * @return
     */
    public static int lengthOfLongestSubstring(String s) {
        // "afsdfdfsdf" afsd 4
        if(StringUtils.isEmpty(s)){
            return 0;
        }
        if(s.length() == 1){
            return 1;
        }
        // 最大长度
        int maxLength = 0;
        String temp = "" ;
        for (int i = 0; i < s.length(); i++) {
            char c = s.charAt(i);
            boolean contains = temp.contains(String.valueOf(c));
            if(contains){
                // 初始化temp
                temp = "" + c;

            }else{
                temp = temp + c;
                System.out.println(temp);
                int length = temp.length();
                if(maxLength < length){
                    maxLength = length;
                }
            }
        }

        return maxLength;
    }


    /**
     * 数组中俩个数的最大异或值 暴力轮询/还有字典树结构
     * @param nums
     * @return
     */
    public int findMaximumXOR(int[] nums) {
        if(null == nums){
            return 0;
        }
        if(nums.length <= 1){
            return nums[0];
        }
        int max = 0;

        for (int i = 0; i < nums.length; i++) {
            for(int j=i+1; j < nums.length; j++){
                int temp =  nums[i] ^ nums[j];
                if(max < temp){
                    max = temp;
                }
            }
        }
        return max;
    }
    /**
     * z 字变换
     * @author fuqiang
     * @date 2021/10/7 16:05
     * @param s
     * @param numRows
     * @return java.lang.String
     */
    public static String convert(String s, int numRows) {
        if (s == null) {
            return null;
        }
        if (s.length() == 1) {
            return s;
        }
        StringBuilder ret = new StringBuilder();
        int n = s.length();
        int cycleLen = 2 * numRows - 2;

        for (int i = 0; i < numRows; i++) {
            for (int j = 0; j + i < n; j += cycleLen) {
                ret.append(s.charAt(i+j));
                if (i != 0 && i != numRows - 1 && j + cycleLen - i < n){
                    ret.append(s.charAt(j + cycleLen - i));
                }
            }
        }
        return ret.toString();
    }
    /**
     * 整数反转, 拆分后 每个数值乘以10 是关键。 然后判断是否溢出 Integer.max_value
     * @author fuqiang
     * @date 2021/10/10 17:22
     * @param x
     * @return int
     */
    public static int reverse(int x) {
        if (x == 0) {
            return 0;
        }
        // 判断x正负
        int var = x > 0 ? 1 : -1;
        StringBuilder sb = new StringBuilder();
        while (true) {
            x = Math.abs(x);
            int temp = x % 10;
            sb.append(temp);
            x = x / 10;
            if( x == 0){
                break;
            }
        }
        Integer value = Integer.valueOf(sb.toString().equals("") == true ? "0" : sb.toString());
        return value * var;
    }

    /**
     * 使其能将字符串转换成一个 32 位有符号整数（类似 C/C++ 中的 atoi 函数）。
     * @param str 字符串
     * @return
     */
    public static int myAtoi(String str){
        if (StringUtils.isEmpty(str)) {
            return 0;
        }
        str = str.trim();
        // 获取正负号
        boolean isMines = false;
        char c = str.charAt(0);
        // 长度为1 并且字符不为数字 则结束
        if (1 == str.length() && !StringUtils.isNumeric(String.valueOf(str.charAt(0)))) {
            return 0;
        }
        if ('-' == c) {
            isMines = true;
            str = str.substring(1);
        }

        for (int i = 0; i < str.length(); i++) {
            char tempChar = str.charAt(i);

            Integer.parseInt(String.valueOf(tempChar));

        }
        return 0;
    }
    public static void main(String[] args) {
        System.out.println(reverse(1534236469));
    }
}
